home *** CD-ROM | disk | FTP | other *** search
/ Aminet 6 / Aminet 6 - June 1995.iso / Aminet / dev / c / LEDA_GUI.lha / files.lha / incl / LEDA / basic.h
Encoding:
C/C++ Source or Header  |  1995-02-06  |  5.5 KB  |  219 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1.2
  4. +
  5. +
  6. +  basic.h
  7. +
  8. +
  9. +  Copyright (c) 1995  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 66123 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16.  
  17. #ifndef LEDA_BASIC_H
  18. #define LEDA_BASIC_H
  19.  
  20. #include <stdlib.h>
  21.  
  22. //------------------------------------------------------------------------------
  23. // compiler/system dependent definitions and includes
  24. //------------------------------------------------------------------------------
  25.  
  26. #if defined(__SVR4) || defined(__SVR4__)
  27. #define __svr4__
  28. #endif
  29.  
  30. // g++ (version < 2.6), bcc, and ztc cannot handle template functions correctly
  31. // and we have to use the LEDA_TYPE_PARAMETER macro for class type arguments.
  32. // (see <LEDA>/prog/basic/param.c for an example)
  33.  
  34. #define __TEMPLATE_FUNCTIONS__
  35.  
  36. #if (__GNUC__ == 2 && __GNUC_MINOR__ < 6 ) || defined(__ZTC__) || defined(__BORLANDC__)
  37. #undef __TEMPLATE_FUNCTIONS__
  38. #endif
  39.  
  40. // currently only g++ (>= 2.6) has a built-in boolean type
  41.  
  42. #if (__GNUC__ > 1 && __GNUC_MINOR__ > 5)
  43. #define __BUILTIN_BOOL__
  44. #endif
  45.  
  46.  
  47. // begin_cdr
  48. // Amiga GCC 2.6.3 has inconsistent include files
  49.  
  50. #if defined(AMIGA)
  51. #define MAXFLOAT    FLT_MAX
  52. #define MAXDOUBLE    DBL_MAX
  53. #define MINFLOAT    FLT_MIN
  54. #define MINDOUBLE    DBL_MIN
  55. // value of AHZ (<sys/acct.h>)
  56. #define HZ 64
  57. #endif
  58. // end_cdr
  59.  
  60.  
  61. // linux defines random as a macro 
  62. #if defined(random)
  63. #undef random
  64. #endif
  65.  
  66.  
  67. // we assume that ztc and wcc are used under DOS
  68.  
  69. #if defined(__ZTC__) || defined(__WATCOMC__)
  70. #define __MSDOS__
  71. #endif
  72.  
  73.  
  74.  
  75. // DOS and EMX have no <values.h>
  76.  
  77. #if defined(__MSDOS__) || defined(__EMX__)
  78. #define MAXINT          (int(0x7FFFFFFF))
  79. #define MAXFLOAT    (float(3.37E+38))
  80. #define MAXDOUBLE       (double(1.797693E+308))
  81. #else
  82. #include <values.h>
  83. #endif
  84.  
  85.  
  86. // EMX and WCC  have no PI in <math.h>
  87. #if defined(__WATCOMC__) || defined (__EMX__)
  88. #define    M_PI 3.14159265358979323846
  89. #endif
  90.  
  91.  
  92. // ztc header files end with .hpp
  93. #if defined(__ZTC__)
  94. #include <iostream.hpp>
  95. #else
  96. #include <iostream.h>
  97. #endif
  98.  
  99.  
  100.  
  101. //------------------------------------------------------------------------------
  102. // Global Types
  103. //------------------------------------------------------------------------------
  104.  
  105. typedef void* GenPtr;    // generic pointer type
  106.  
  107. enum rel_pos   { before = 1, after = 0 };
  108. enum direction { forward = 0, backward = 1 };
  109.  
  110. #define nil 0
  111.  
  112.  
  113. //------------------------------------------------------------------------------
  114. // STRINGIZE: turning a macro argument into a string
  115. //------------------------------------------------------------------------------
  116.  
  117. #if defined(__STDC__)  || defined(__MSDOS__)
  118. #define STRINGIZE(x) #x
  119. #else
  120. #define STRINGIZE(x) "x"
  121. #endif
  122.  
  123.  
  124. //------------------------------------------------------------------------------
  125. // automatically included LEDA header files
  126. //------------------------------------------------------------------------------
  127.  
  128. #include <LEDA/leda.h>
  129. #include <LEDA/error.h>
  130. #include <LEDA/memory.h>
  131. #include <LEDA/param_types.h>
  132. #include <LEDA/handle_types.h>
  133. #include <LEDA/bool.h>
  134. #include <LEDA/string.h>
  135. #include <LEDA/random.h>
  136. #include <LEDA/misc.h>
  137.  
  138.  
  139.  
  140. //------------------------------------------------------------------------------
  141. // Defining Linear Orders
  142. //------------------------------------------------------------------------------
  143.  
  144. #define DEFINE_LINEAR_ORDER(type,cmp,new_type)\
  145. struct new_type : public type\
  146. { new_type(type s)            : type(s) {}\
  147.   new_type(const new_type& s) : type(s) {}\
  148.   new_type() {}\
  149.  ~new_type() {}\
  150. };\
  151. inline int compare(const new_type& x, const new_type& y) { return cmp(x,y); }
  152.  
  153.  
  154. // INT<cmp>: int with user defined linear order cmp
  155.  
  156. typedef int (*CMP_INT_TYPE)(const int&, const int&);
  157.  
  158.  
  159. template<CMP_INT_TYPE cmp> class INT {
  160.  
  161.  int p;
  162.  
  163.  public:
  164.  INT(const int i=0) { p = i;}
  165.  operator int()     { return p; }
  166.  
  167. friend void Print(const INT<cmp>& x, ostream& out) { out << x.p; }
  168. friend void Read(INT<cmp>&  x, istream& in)        { in  >> x.p; }
  169. friend void Init(INT<cmp>&  x)            { x.p=0; }
  170. friend GenPtr Copy(const INT<cmp>& x)     { return GenPtr(x); }
  171. friend void Clear(INT<cmp>& x)            { x.p = 0; }
  172. friend GenPtr Convert(const INT<cmp>& x)  { return GenPtr(x.p); }
  173. friend INT<cmp>& Access(INT<cmp>*,const GenPtr& p) { return *(INT<cmp>*)&p; }
  174. friend int compare(const INT<cmp>& x, const INT<cmp>& y) { return cmp(x.p,y.p);}
  175. };
  176.  
  177.  
  178.  
  179. //------------------------------------------------------------------------------
  180. // ITERATION 
  181. //------------------------------------------------------------------------------
  182.  
  183. #define forall_items(x,S) for(x = (S).first_item(); x; x = (S).next_item(x) )
  184.  
  185. /*
  186.    To avoid multiple declarations of the "forall_loop_item" variable
  187.    we use a dummy for-loop to create a new scope for it.
  188.    This, however, does not work with all compilers (ztc,lucid ...)
  189.    and we have to use the old forall mechanism (no nesting).
  190. */
  191.   
  192. #if defined(__ZTC__) || defined(__lucid)
  193.  
  194. #define forall(x,S)\
  195. for((S).start_iteration(); (S).read_iterator(x); (S).move_to_succ())
  196.  
  197. #define Forall(x,S)\
  198. for((S).Start_iteration(); (S).read_iterator(x); (S).move_to_pred())
  199.  
  200. #else
  201.  
  202. #define forall(x,S)\
  203. for(LEDA::loop_dummy=0; LEDA::loop_dummy<1; LEDA::loop_dummy++)\
  204. for(GenPtr forall_loop_item=(S).first_item();\
  205. (S).forall_loop_test(forall_loop_item,x);\
  206. (S).loop_to_succ(forall_loop_item))
  207.  
  208. #define Forall(x,S)\
  209. for(LEDA::loop_dummy=0; LEDA::loop_dummy<1; LEDA::loop_dummy++)\
  210. for(GenPtr forall_loop_item=(S).last_item();\
  211. (S).forall_loop_test(forall_loop_item,x);\
  212. (S).loop_to_pred(forall_loop_item))
  213.  
  214. #endif
  215.  
  216.  
  217.  
  218. #endif
  219.